home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update27.zoo / gcc-233 / gcc-233.diff < prev    next >
Encoding:
Text File  |  1992-12-28  |  64.9 KB  |  2,428 lines
  1. diff -c -r ngcc/c-decl.c gcc/c-decl.c
  2. *** ngcc/c-decl.c    Mon Dec 28 00:44:14 1992
  3. --- gcc/c-decl.c    Mon Dec 28 00:27:25 1992
  4. ***************
  5. *** 5885,5890 ****
  6. --- 5885,5892 ----
  7.   
  8.     expand_function_start (fndecl, 0);
  9.   
  10. + #if (!(defined(atarist) || defined(CROSSATARI) || defined(atariminix)))
  11. +   /* we will only need this in cp-decl.c, not here */
  12.     /* If this function is `main', emit a call to `__main'
  13.        to run global initializers, etc.  */
  14.     if (DECL_NAME (fndecl)
  15. ***************
  16. *** 5891,5896 ****
  17. --- 5893,5899 ----
  18.         && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0
  19.         && DECL_CONTEXT (fndecl) == NULL_TREE)
  20.       expand_main_function ();
  21. + #endif
  22.   }
  23.   
  24.   /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
  25. diff -c -r ngcc/c-lex.c gcc/c-lex.c
  26. *** ngcc/c-lex.c    Mon Nov 30 15:33:14 1992
  27. --- gcc/c-lex.c    Mon Dec 28 00:27:29 1992
  28. ***************
  29. *** 391,396 ****
  30. --- 391,397 ----
  31.       case '\r':
  32.         /* ANSI C says the effects of a carriage return in a source file
  33.            are undefined.  */
  34. + #ifndef atarist /* but not on an atarist, though hopefully we should'nt see it */
  35.         if (pedantic && !newline_warning)
  36.           {
  37.             warning ("carriage return in source file");
  38. ***************
  39. *** 397,402 ****
  40. --- 398,404 ----
  41.             warning ("(we only warn about the first carriage return)");
  42.             newline_warning = 1;
  43.           }
  44. + #endif
  45.         c = getc (finput);
  46.         break;
  47.   
  48. diff -c -r ngcc/cccp.c gcc/cccp.c
  49. *** ngcc/cccp.c    Mon Dec 28 00:44:16 1992
  50. --- gcc/cccp.c    Mon Dec 28 00:27:32 1992
  51. ***************
  52. *** 71,76 ****
  53. --- 71,78 ----
  54.   #undef bzero
  55.   #undef bcmp
  56.   
  57. + #ifndef atarist
  58. + 
  59.   #include <sys/types.h>
  60.   #include <sys/stat.h>
  61.   #include <ctype.h>
  62. ***************
  63. *** 77,91 ****
  64.   #include <stdio.h>
  65.   
  66.   #ifndef VMS
  67. ! #ifndef USG
  68.   #include <sys/time.h>        /* for __DATE__ and __TIME__ */
  69.   #include <sys/resource.h>
  70.   #else
  71.   #include <time.h>
  72.   #include <fcntl.h>
  73. ! #endif /* USG */
  74.   #endif /* not VMS */
  75.   
  76.   /* VMS-specific definitions */
  77.   #ifdef VMS
  78.   #include <time.h>
  79. --- 79,111 ----
  80.   #include <stdio.h>
  81.   
  82.   #ifndef VMS
  83. ! #if (!(defined(USG) || defined(atariminix)))
  84.   #include <sys/time.h>        /* for __DATE__ and __TIME__ */
  85.   #include <sys/resource.h>
  86.   #else
  87.   #include <time.h>
  88.   #include <fcntl.h>
  89. ! #endif /* USG or atariminix */
  90.   #endif /* not VMS */
  91.   
  92. + #else    /* atarist */
  93. + 
  94. + #include <ctype.h>
  95. + #include <stdio.h>
  96. + #include <types.h>
  97. + #include <stat.h>
  98. + #include <file.h>
  99. + #include <time.h>
  100. + #include <string.h>
  101. + #include "stddef.h"
  102. + 
  103. + long _stksize = -1L;    /* want big stack cause include files
  104. +                    get alloca'ed there */
  105. + 
  106. + #define read(fd,buf,size)    _text_read(fd,buf,size)
  107. + 
  108. + #endif        /* atarist */
  109. + 
  110.   /* VMS-specific definitions */
  111.   #ifdef VMS
  112.   #include <time.h>
  113. ***************
  114. *** 925,930 ****
  115. --- 945,971 ----
  116.   /* Nonzero means -I- has been seen,
  117.      so don't look for #include "foo" the source-file directory.  */
  118.   static int ignore_srcdir;
  119. +  
  120. + #ifdef atarist
  121. + /* the following dingus is used in place of some calls to bcopy,
  122. +    to ensure that backslashes get properly slashified when getting
  123. +    shoved into strings.  Note that it returns the new pointer!!
  124. +    There ought to be a better way... */
  125. + 
  126. + U_CHAR * slashifying_bcopy(from_buf, to_buf, nbytes)
  127. + U_CHAR * from_buf, * to_buf;
  128. + int nbytes;
  129. + {
  130. +   for ( ; nbytes > 0 ; )
  131. +     {
  132. +     if(*from_buf == '\\')
  133. +         *to_buf++ = '\\';
  134. +     *to_buf++ = *from_buf++;
  135. +     nbytes--;
  136. +     }
  137. +   return(to_buf);
  138. + }
  139. + #endif        /* atarist */
  140.   
  141.   int
  142.   main (argc, argv)
  143. ***************
  144. *** 963,968 ****
  145. --- 1004,1014 ----
  146.     /* Target-name to write with the dependency information.  */
  147.     char *deps_target = 0;
  148.   
  149. + #ifdef atarist
  150. + /* turn this on if you are going to set the TOS 1.4 dont clear heap flag */
  151. + /*  _malloczero(1); */     /* zero mallocs by default */
  152. + #endif  
  153. + 
  154.   #ifdef RLIMIT_STACK
  155.     /* Get rid of any avoidable limit on stack size.  */
  156.     {
  157. ***************
  158. *** 1210,1219 ****
  159. --- 1256,1271 ----
  160.       break;
  161.   
  162.         case 'v':
  163. + #if (defined(atarist) || defined(CROSSATARI) || defined(atariminix))
  164. + #include "PatchLev.h"
  165. +     fprintf (stderr, "GNU CPP-atariST version %s Patchlevel %s",
  166. +          version_string, PatchLevel);
  167. + #else
  168.       fprintf (stderr, "GNU CPP version %s", version_string);
  169.   #ifdef TARGET_VERSION
  170.       TARGET_VERSION;
  171.   #endif
  172. + #endif
  173.       fprintf (stderr, "\n");
  174.       break;
  175.   
  176. ***************
  177. *** 1345,1350 ****
  178. --- 1397,1403 ----
  179.       }
  180.     }
  181.   
  182. + #if (!(defined(atarist) || defined(CROSSATARI) || defined(atariminix)))
  183.     /* Add dirs from CPATH after dirs from -I.  */
  184.     /* There seems to be confusion about what CPATH should do,
  185.        so for the moment it is not documented.  */
  186. ***************
  187. *** 1354,1359 ****
  188. --- 1407,1413 ----
  189.     p = (char *) getenv ("CPATH");
  190.     if (p != 0 && ! no_standard_includes)
  191.       path_include (p);
  192. + #endif
  193.   
  194.     /* Now that dollars_in_ident is known, initialize is_idchar.  */
  195.     initialize_char_syntax ();
  196. ***************
  197. *** 1472,1479 ****
  198.     { /* read the appropriate environment variable and if it exists
  199.          replace include_defaults with the listed path. */
  200.       char *epath = 0;
  201.       switch ((objc << 1) + cplusplus)
  202. !       {
  203.         case 0:
  204.       epath = getenv ("C_INCLUDE_PATH");
  205.       break;
  206. --- 1526,1581 ----
  207.     { /* read the appropriate environment variable and if it exists
  208.          replace include_defaults with the listed path. */
  209.       char *epath = 0;
  210. + #if (defined(atarist) || defined(CROSSATARI) || defined(atariminix))
  211. +     int db_hack = 0;
  212. +     char *e1 = getenv("GNUINC"), *e2 = getenv("GNULIB"),
  213. +          *e3 = getenv("GXXINC");
  214. + 
  215. + 
  216. +     /* Get length of the alloc'ed array. (Yeah I know, I might alloc
  217. +      * a character more than I need but who cares...
  218. +      */
  219. +     if (cplusplus && e3)
  220. +     db_hack += strlen (e3);
  221. +     if (e1)
  222. +         db_hack += strlen (e1) + 1;
  223. +     if (e2)
  224. +         db_hack += strlen (e1) + 1;
  225. + 
  226. +     if (db_hack) {
  227. +     epath = alloca (db_hack + 1);
  228. +     *epath = '\0';
  229. +     db_hack = 0;
  230. + 
  231. +     /* Concatenate the paths together. */
  232. +     if (cplusplus && e3) {
  233. +         strcpy (epath, e3);
  234. +         db_hack = 1;
  235. +     }
  236. +     if (e1) {
  237. +         if (db_hack) {
  238. +         strcat (epath, PATH_SEP_STR);
  239. +         }
  240. +         strcat (epath, e1);
  241. +         db_hack = 1;
  242. +     }
  243. +     if (e2) {
  244. +         if (db_hack) {
  245. +         strcat (epath, PATH_SEP_STR);
  246. +         }
  247. +         strcat (epath, e2);
  248. +     }
  249. +     }
  250. + 
  251. + #ifdef atarist
  252. +     if (epath)
  253. +         for (e3=epath; *e3; e3++)    /* Use one kind of path separator */
  254. +         if (*e3 == ';')
  255. +         *e3 = PATH_SEPARATOR;
  256. + #endif
  257. + #else
  258.       switch ((objc << 1) + cplusplus)
  259. !     {
  260.         case 0:
  261.       epath = getenv ("C_INCLUDE_PATH");
  262.       break;
  263. ***************
  264. *** 1486,1492 ****
  265.         case 3:
  266.       epath = getenv ("OBJCPLUS_INCLUDE_PATH");
  267.       break;
  268. !       }
  269.       /* If the environment var for this language is set,
  270.          add to the default list of include directories.  */
  271.       if (epath) {
  272. --- 1588,1596 ----
  273.         case 3:
  274.       epath = getenv ("OBJCPLUS_INCLUDE_PATH");
  275.       break;
  276. !     }
  277. ! #endif
  278. ! 
  279.       /* If the environment var for this language is set,
  280.          add to the default list of include directories.  */
  281.       if (epath) {
  282. ***************
  283. *** 1540,1546 ****
  284. --- 1644,1654 ----
  285.     if (!no_standard_includes) {
  286.       struct default_include *p = include_defaults;
  287.       char *specd_prefix = include_prefix;
  288. + #ifdef GCC_INCLUDE_DIR
  289.       char *default_prefix = savestring (GCC_INCLUDE_DIR);
  290. + #else
  291. +     char *default_prefix = savestring ("./");
  292. + #endif
  293.       int default_len = 0;
  294.       /* Remove the `include' from /usr/local/lib/gcc.../include.  */
  295.       if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
  296. ***************
  297. *** 1547,1552 ****
  298. --- 1655,1666 ----
  299.         default_len = strlen (default_prefix) - 7;
  300.         default_prefix[default_len] = 0;
  301.       }
  302. + #ifdef atarist
  303. +     else if (!strcmp (default_prefix + strlen (default_prefix) - 8, "\\include")) {
  304. +       default_len = strlen (default_prefix) - 7;
  305. +       default_prefix[default_len] = 0;
  306. +     }
  307. + #endif
  308.       /* Search "translated" versions of GNU directories.
  309.          These have /usr/local/lib/gcc... replaced by specd_prefix.  */
  310.       if (specd_prefix != 0 && default_len != 0)
  311. ***************
  312. *** 1673,1679 ****
  313. --- 1787,1797 ----
  314.         char *p1 = p;
  315.         /* Discard all directory prefixes from P.  */
  316.         while (*p1) {
  317. + #ifdef atarist
  318. +     if ((*p1 == '/') || (*p1 == '\\'))
  319. + #else
  320.       if (*p1 == '/')
  321. + #endif
  322.         p = p1 + 1;
  323.       p1++;
  324.         }
  325. ***************
  326. *** 1835,1840 ****
  327. --- 1953,1959 ----
  328.     return 0;
  329.   }
  330.   
  331. + #if (!(defined(atarist) || defined(CROSSATARI) || defined(atariminix)))
  332.   /* Given a colon-separated list of file names PATH,
  333.      add all the names to the search path for include files.  */
  334.   
  335. ***************
  336. *** 1881,1886 ****
  337. --- 2000,2006 ----
  338.         p++;
  339.       }
  340.   }
  341. + #endif /* atarist */
  342.   
  343.   /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
  344.      before main CCCP processing.  Name `pcp' is also in honor of the
  345. ***************
  346. *** 3040,3045 ****
  347. --- 3160,3166 ----
  348.     assertions_flag = save_assertions_flag;
  349.     return obuf;
  350.   }
  351. + /* #endif */
  352.   
  353.   /*
  354.    * Process a # directive.  Expects IP->bufp to point after the '#', as in
  355. ***************
  356. *** 3501,3508 ****
  357. --- 3622,3638 ----
  358.   
  359.         if (string)
  360.       {
  361. + #ifndef atarist
  362.         buf = (char *) alloca (3 + strlen (string));
  363.         sprintf (buf, "\"%s\"", string);
  364. + #else
  365. +           buf = (char *) alloca (16 + strlen (string));
  366. +           {
  367. +           char *tbuf = (char *) alloca (16 + strlen (string));
  368. +           (void) slashifying_bcopy(string, tbuf, strlen(string)+1);
  369. +           sprintf (buf, "\"%s\"", tbuf);
  370. +           }
  371. + #endif /* atarist */
  372.       }
  373.         else
  374.       buf = "\"\"";
  375. ***************
  376. *** 3724,3730 ****
  377. --- 3854,3865 ----
  378.           dsp[0].next = search_start;
  379.           search_start = dsp;
  380.   #ifndef VMS
  381. + #ifdef atarist
  382. +         if((ep = rindex(nam, '\\')) == NULL)
  383. +         ep = rindex(nam, '/');
  384. + #else
  385.           ep = rindex (nam, '/');
  386. + #endif
  387.   #else                /* VMS */
  388.           ep = rindex (nam, ']');
  389.           if (ep == NULL) ep = rindex (nam, '>');
  390. ***************
  391. *** 3800,3808 ****
  392. --- 3935,3957 ----
  393.   
  394.     /* If specified file name is absolute, just open it.  */
  395.   
  396. + #ifdef atarist
  397. +   if ((*fbeg == '\\') || (*fbeg == '/')) {
  398. +     if(fbeg[2] == ':')
  399. +     { /* allow "\D:\xxx" */
  400. +         strncpy (fname, fbeg+1, flen-1);
  401. +         fname[flen-1] = 0;
  402. +     }
  403. +     else
  404. +     {  /* allow "\lib\xxx" == "\currentdrive:\lib\xxx" */
  405. +         strncpy (fname, fbeg, flen);
  406. +         fname[flen] = 0;
  407. +     }
  408. + #else
  409.     if (*fbeg == '/') {
  410.       strncpy (fname, fbeg, flen);
  411.       fname[flen] = 0;
  412. + #endif
  413.       if (redundant_include_p (fname))
  414.         return 0;
  415.       if (importing)
  416. ***************
  417. *** 3823,3829 ****
  418. --- 3972,3982 ----
  419.       if (searchptr->fname[0] == 0)
  420.         continue;
  421.       strcpy (fname, searchptr->fname);
  422. + #ifdef atarist
  423. +     strcat (fname, "\\");
  424. + #else
  425.       strcat (fname, "/");
  426. + #endif
  427.       fname[strlen (fname) + flen] = 0;
  428.         } else {
  429.       fname[0] = 0;
  430. ***************
  431. *** 3945,3961 ****
  432.   
  433.       if (!no_precomp)
  434.         do {
  435.       sprintf (pcftry, "%s%d", fname, pcfnum++);
  436.       
  437.       pcf = open (pcftry, O_RDONLY, 0666);
  438.       if (pcf != -1)
  439.         {
  440.           struct stat s;
  441.   
  442.           fstat (pcf, &s);
  443.           if (bcmp (&stat_f.st_ino, &s.st_ino, sizeof (s.st_ino))
  444.           || stat_f.st_dev != s.st_dev)
  445. !           {
  446.           pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
  447.           /* Don't need it any more.  */
  448.           close (pcf);
  449. --- 4098,4156 ----
  450.   
  451.       if (!no_precomp)
  452.         do {
  453. + #ifdef atarist
  454. +     int numlen;
  455. +     char *dot;
  456. +     char *slash;
  457. + 
  458. +     /* cut extension to 3 chars and dont depend on UNIXMODE           */
  459. +     /* this will have to be done when saving precompiled headers, too */
  460. +     /* but as far as I tried, they dont work up to now, anyway   (AL) */
  461. + 
  462. +       if( pcfnum>=100 )     numlen=3;
  463. +       else if( pcfnum>=10 ) numlen=2;
  464. +       else                  numlen=1;
  465. + 
  466. +       dot=strrchr( fname, '.' );
  467. +       if( (slash=strrchr( fname, '/')) && slash>dot )
  468. +         dot=NULL;
  469. +       else
  470. +       if( (slash=strrchr( fname, '\\')) && slash>dot )
  471. +         dot=NULL;
  472. + 
  473. +       if( dot ) {
  474. +         if( strlen(dot)-1>3-numlen ) {
  475. +           sprintf(pcftry, "%.*s%d", strlen(fname)-(strlen(dot)-(4-numlen)),
  476. +                   fname, pcfnum++);
  477. +         } else {
  478. +           sprintf(pcftry, "%s%d", fname, pcfnum++);
  479. +         }
  480. +       } else {
  481. +         sprintf( pcftry, "%s.%d", fname, pcfnum++);
  482. +       }
  483. + #else    /* looks like we got a sane filesystem */
  484.       sprintf (pcftry, "%s%d", fname, pcfnum++);
  485. + #endif
  486. + #if 0
  487. +     fprintf ( stderr, "trying precompiled file %s.\n", pcftry );
  488. + #endif
  489.       
  490.       pcf = open (pcftry, O_RDONLY, 0666);
  491.       if (pcf != -1)
  492.         {
  493. + #ifndef atarist
  494. +         /* dont bother with this on the ST since these field are faked
  495. +          * anyways
  496. +              */
  497.           struct stat s;
  498.   
  499.           fstat (pcf, &s);
  500.           if (bcmp (&stat_f.st_ino, &s.st_ino, sizeof (s.st_ino))
  501.           || stat_f.st_dev != s.st_dev)
  502. ! #else
  503. !         if (1)
  504. ! #endif
  505. !               {
  506.           pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
  507.           /* Don't need it any more.  */
  508.           close (pcf);
  509. ***************
  510. *** 6832,6839 ****
  511. --- 7027,7038 ----
  512.     check_expand (op, len + 1);
  513.     if (op->bufp > op->buf && op->bufp[-1] != '\n')
  514.       *op->bufp++ = '\n';
  515. + #ifdef atarist
  516. +   op->bufp = slashifying_bcopy (line_cmd_buf, op->bufp, len);
  517. + #else
  518.     bcopy (line_cmd_buf, op->bufp, len);
  519.     op->bufp += len;
  520. + #endif
  521.     op->lineno = ip->lineno;
  522.   }
  523.   
  524. ***************
  525. *** 8477,8482 ****
  526. --- 8676,8682 ----
  527.     deps_buffer[deps_size] = 0;
  528.   }
  529.   
  530. + #if (!(defined(atarist) || defined(atariminix)))
  531.   #if defined(USG) || defined(VMS)
  532.   #ifndef BSTRING
  533.   
  534. ***************
  535. *** 8513,8519 ****
  536.   }
  537.   #endif /* not BSTRING */
  538.   #endif /* USG or VMS */
  539. ! 
  540.   
  541.   static void
  542.   fatal (str, arg)
  543. --- 8713,8719 ----
  544.   }
  545.   #endif /* not BSTRING */
  546.   #endif /* USG or VMS */
  547. ! #endif /* any atari */
  548.   
  549.   static void
  550.   fatal (str, arg)
  551. diff -c -r ngcc/config/alpha.h gcc/config/alpha.h
  552. *** ngcc/config/alpha.h    Mon Dec 28 00:44:21 1992
  553. --- gcc/config/alpha.h    Mon Dec 28 00:28:26 1992
  554. ***************
  555. *** 1256,1262 ****
  556.   { extern char *version_string;                    \
  557.     char *p, *after_dir = main_input_filename;            \
  558.                                   \
  559. !   fprintf (FILE, "\t.verstamp 9 0 ");                \
  560.     for (p = version_string; *p != ' ' && *p != 0; p++)        \
  561.       fprintf (FILE, "%c", *p == '.' ? ' ' : *p);            \
  562.     fprintf (FILE, "\n\t.set noreorder\n");            \
  563. --- 1256,1262 ----
  564.   { extern char *version_string;                    \
  565.     char *p, *after_dir = main_input_filename;            \
  566.                                   \
  567. !   fprintf (FILE, "\t.verstamp 8 0 ");                \
  568.     for (p = version_string; *p != ' ' && *p != 0; p++)        \
  569.       fprintf (FILE, "%c", *p == '.' ? ' ' : *p);            \
  570.     fprintf (FILE, "\n\t.set noreorder\n");            \
  571. diff -c -r ngcc/config/m68k.c gcc/config/m68k.c
  572. *** ngcc/config/m68k.c    Mon Nov 30 15:37:41 1992
  573. --- gcc/config/m68k.c    Mon Dec 28 00:28:29 1992
  574. ***************
  575. *** 60,66 ****
  576.      
  577.   finalize_pic ()
  578.   {
  579. !   if (flag_pic && current_function_uses_pic_offset_table)
  580.       emit_insn (gen_rtx (USE, VOIDmode, pic_offset_table_rtx));
  581.   }
  582.   
  583. --- 60,66 ----
  584.      
  585.   finalize_pic ()
  586.   {
  587. !   if (flag_pic && (flag_pic < 3) && current_function_uses_pic_offset_table)
  588.       emit_insn (gen_rtx (USE, VOIDmode, pic_offset_table_rtx));
  589.   }
  590.   
  591. ***************
  592. *** 213,219 ****
  593.         asm_fprintf (stream, "\tmoveml %0I0x%x,%Rsp@-\n", mask);
  594.   #endif
  595.       }
  596. !   if (flag_pic && current_function_uses_pic_offset_table)
  597.       {
  598.   #ifdef MOTOROLA
  599.         asm_fprintf (stream, "\t%Omove.l %0I__GLOBAL_OFFSET_TABLE_, %s\n",
  600. --- 213,219 ----
  601.         asm_fprintf (stream, "\tmoveml %0I0x%x,%Rsp@-\n", mask);
  602.   #endif
  603.       }
  604. !   if (flag_pic && (flag_pic < 3) && current_function_uses_pic_offset_table)
  605.       {
  606.   #ifdef MOTOROLA
  607.         asm_fprintf (stream, "\t%Omove.l %0I__GLOBAL_OFFSET_TABLE_, %s\n",
  608. ***************
  609. *** 803,814 ****
  610.     /* First handle a simple SYMBOL_REF or LABEL_REF */
  611.     if (GET_CODE (orig) == SYMBOL_REF || GET_CODE (orig) == LABEL_REF)
  612.       {
  613.         if (reg == 0)
  614.       abort ();
  615.   
  616. !       pic_ref = gen_rtx (MEM, Pmode,
  617. !              gen_rtx (PLUS, Pmode,
  618. !                   pic_offset_table_rtx, orig));
  619.         current_function_uses_pic_offset_table = 1;
  620.         RTX_UNCHANGING_P (pic_ref) = 1;
  621.         emit_move_insn (reg, pic_ref);
  622. --- 803,822 ----
  623.     /* First handle a simple SYMBOL_REF or LABEL_REF */
  624.     if (GET_CODE (orig) == SYMBOL_REF || GET_CODE (orig) == LABEL_REF)
  625.       {
  626. + #ifdef LEGITIMATE_BASEREL_OPERAND_P
  627. +   if (LEGITIMATE_BASEREL_OPERAND_P (orig))
  628. +     return orig;
  629. + #endif
  630. + 
  631.         if (reg == 0)
  632.       abort ();
  633.   
  634. !       if (flag_pic == 3)
  635. !         pic_ref = gen_rtx (PLUS, Pmode, pic_offset_table_rtx, orig);
  636. !       else
  637. !         pic_ref = gen_rtx (MEM, Pmode,
  638. !                gen_rtx (PLUS, Pmode,
  639. !                     pic_offset_table_rtx, orig));
  640.         current_function_uses_pic_offset_table = 1;
  641.         RTX_UNCHANGING_P (pic_ref) = 1;
  642.         emit_move_insn (reg, pic_ref);
  643. ***************
  644. *** 840,845 ****
  645. --- 848,854 ----
  646.         pic_ref = gen_rtx (PLUS, Pmode, base, orig);
  647.         /* Likewise, should we set special REG_NOTEs here?  */
  648.       }
  649. + 
  650.     return pic_ref;
  651.   }
  652.   
  653. ***************
  654. *** 1582,1587 ****
  655. --- 1591,1599 ----
  656.         output_address (XEXP (op, 0));
  657.         if (letter == 'd' && ! TARGET_68020
  658.         && CONSTANT_ADDRESS_P (XEXP (op, 0))
  659. +       && !(TARGET_PC_REL && GET_CODE (XEXP (op, 0)) == SYMBOL_REF
  660. +            && SYMBOL_REF_FLAG (XEXP (op, 0))
  661. +            && !SYMBOL_REF_USED (XEXP (op, 0)))
  662.         && !(GET_CODE (XEXP (op, 0)) == CONST_INT
  663.              && INTVAL (XEXP (op, 0)) < 0x8000
  664.              && INTVAL (XEXP (op, 0)) >= -0x8000))
  665. ***************
  666. *** 1887,1892 ****
  667. --- 1899,1906 ----
  668.                 fprintf (file, ":w");
  669.               if ((flag_pic == 2) && (breg == pic_offset_table_rtx))
  670.                 fprintf (file, ":l");
  671. +             if ((flag_pic == 3) && (breg == pic_offset_table_rtx))
  672. +               fprintf (file, ":W");
  673.             }
  674.           if (addr != 0 && ireg != 0)
  675.             {
  676. ***************
  677. *** 1964,1969 ****
  678. --- 1978,1996 ----
  679.           fprintf (file, "%d:w", INTVAL (addr));
  680.   #endif
  681.         }
  682. +     else if (TARGET_PC_REL && GET_CODE (addr) == SYMBOL_REF
  683. +          && SYMBOL_REF_FLAG (addr)
  684. +          && !SYMBOL_REF_USED (addr))
  685. +       {
  686. + #ifdef MOTOROLA
  687. +         output_addr_const (file, addr);
  688. +         fputs ("(pc)", file);
  689. + #else
  690. +         fputs ("pc@(", file);
  691. +         output_addr_const (file, addr);
  692. +         putc (')', file);
  693. + #endif
  694. +       }
  695.       else
  696.         {
  697.           output_addr_const (file, addr);
  698. ***************
  699. *** 1971,1973 ****
  700. --- 1998,2015 ----
  701.       break;
  702.       }
  703.   }
  704. + #ifdef ENCODE_SECTION_INFO
  705. + /* Does operand (which is a symbolic_operand) live in text space? If
  706. +    so SYMBOL_REF_FLAG, which is set by ENCODE_SECTION_INFO, will be true.*/
  707. + 
  708. + int
  709. + read_only_operand (operand)
  710. +      rtx operand;
  711. + {
  712. +   if (GET_CODE (operand) == CONST)
  713. +     operand = XEXP (XEXP (operand, 0), 0);
  714. +   if (GET_CODE (operand) == SYMBOL_REF)
  715. +     return SYMBOL_REF_FLAG (operand) || CONSTANT_POOL_ADDRESS_P (operand);
  716. +   return 1;
  717. + }
  718. + #endif
  719. diff -c -r ngcc/config/m68k.h gcc/config/m68k.h
  720. *** ngcc/config/m68k.h    Mon Nov 30 15:37:43 1992
  721. --- gcc/config/m68k.h    Mon Dec 28 00:28:31 1992
  722. ***************
  723. *** 92,97 ****
  724. --- 92,103 ----
  725.   /* Use the 68040-only fp instructions (-m68040).  */
  726.   #define TARGET_68040_ONLY (target_flags & 01000)
  727.   
  728. + /* Use PC-relative addressing for refs to read-only data */
  729. + #define TARGET_PC_REL (target_flags & 02000)
  730. + 
  731. + /* Use base-relative addressing for refs to data&bss segments */
  732. + #define TARGET_BASE_REL (target_flags & 04000)
  733. + 
  734.   /* Macro to define tables used to set the flags.
  735.      This is a list in braces of pairs in braces,
  736.      each pair being { "NAME", VALUE }
  737. ***************
  738. *** 119,124 ****
  739. --- 125,134 ----
  740.       { "68030", -01400},                \
  741.       { "68030", 7},                \
  742.       { "68040", 01007},            \
  743. +     { "pcrel", 02000},                \
  744. +     { "nopcrel", -02000},            \
  745. +     { "baserel", 04000},            \
  746. +     { "nobaserel", -04000},            \
  747.       { "", TARGET_DEFAULT}}
  748.   /* TARGET_DEFAULT is defined in sun*.h and isi.h, etc.  */
  749.   
  750. ***************
  751. *** 130,135 ****
  752. --- 140,146 ----
  753.     if (TARGET_FPA) target_flags &= ~2;    \
  754.     if (! TARGET_68020 && flag_pic == 2)    \
  755.       error("-fPIC is not currently supported on the 68000 or 68010\n");    \
  756. +   if (TARGET_BASE_REL) flag_pic = 3;    \
  757.   }
  758.   #else
  759.   #define OVERRIDE_OPTIONS        \
  760. ***************
  761. *** 136,141 ****
  762. --- 147,153 ----
  763.   {                    \
  764.     if (! TARGET_68020 && flag_pic == 2)    \
  765.       error("-fPIC is not currently supported on the 68000 or 68010\n");    \
  766. +   if (TARGET_BASE_REL) flag_pic = 3;    \
  767.   }
  768.   #endif /* defined SUPPORT_SUN_FPA */
  769.   
  770. ***************
  771. *** 327,335 ****
  772.   #ifndef SUPPORT_SUN_FPA
  773.   
  774.   #define CONDITIONAL_REGISTER_USAGE \
  775. ! {                                               \
  776. !   if (flag_pic)                                 \
  777. !     fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1;    \
  778.   }
  779.   
  780.   #else /* defined SUPPORT_SUN_FPA */
  781. --- 339,350 ----
  782.   #ifndef SUPPORT_SUN_FPA
  783.   
  784.   #define CONDITIONAL_REGISTER_USAGE \
  785. ! {                                                \
  786. !   if (flag_pic)                                  \
  787. !     fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1;     \
  788. !   /* prevent saving/restoring of the base reg */ \
  789. !   if (flag_pic == 3)                 \
  790. !     call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1; \
  791.   }
  792.   
  793.   #else /* defined SUPPORT_SUN_FPA */
  794. ***************
  795. *** 1111,1116 ****
  796. --- 1126,1133 ----
  797.          && REG_P (XEXP (X, 0)) && REG_OK_FOR_BASE_P (XEXP (X, 0))    \
  798.          && GET_CODE (XEXP (X, 1)) == CONST_INT                \
  799.          && ((unsigned) INTVAL (XEXP (X, 1)) + 0x8000) < 0x10000)        \
  800. +    || (GET_CODE (X) == PLUS && XEXP (X, 0) == pic_offset_table_rtx     \
  801. +        && flag_pic == 3 && CONSTANT_ADDRESS_P (XEXP (X, 1)))        \
  802.      || (GET_CODE (X) == PLUS && XEXP (X, 0) == pic_offset_table_rtx     \
  803.          && flag_pic && GET_CODE (XEXP (X, 1)) == SYMBOL_REF)        \
  804.      || (GET_CODE (X) == PLUS && XEXP (X, 0) == pic_offset_table_rtx     \
  805. diff -c -r ngcc/config/m68k.md gcc/config/m68k.md
  806. *** ngcc/config/m68k.md    Mon Nov 30 15:37:46 1992
  807. --- gcc/config/m68k.md    Mon Dec 28 00:28:35 1992
  808. ***************
  809. *** 704,716 ****
  810.   {
  811.     if (flag_pic && symbolic_operand (operands[1], SImode)) 
  812.       {
  813. !       /* The source is an address which requires PIC relocation.  
  814. !          Call legitimize_pic_address with the source, mode, and a relocation
  815. !          register (a new pseudo, or the final destination if reload_in_progress
  816. !          is set).   Then fall through normally */
  817. !       extern rtx legitimize_pic_address();
  818. !       rtx temp = reload_in_progress ? operands[0] : gen_reg_rtx (Pmode);
  819. !       operands[1] = legitimize_pic_address (operands[1], SImode, temp);
  820.       }
  821.   }")
  822.   
  823. --- 704,721 ----
  824.   {
  825.     if (flag_pic && symbolic_operand (operands[1], SImode)) 
  826.       {
  827. ! #ifdef LEGITIMATE_BASEREL_OPERAND_P
  828. !       if (flag_pic != 3 || !LEGITIMATE_BASEREL_OPERAND_P (operands[1]))
  829. ! #endif
  830. !       {
  831. !         /* The source is an address which requires PIC relocation.  
  832. !            Call legitimize_pic_address with the source, mode, and a relocation
  833. !            register (a new pseudo, or the final destination if reload_in_progress
  834. !            is set).   Then fall through normally */
  835. !         extern rtx legitimize_pic_address();
  836. !         rtx temp = reload_in_progress ? operands[0] : gen_reg_rtx (Pmode);
  837. !         operands[1] = legitimize_pic_address (operands[1], SImode, temp);
  838. !       }
  839.       }
  840.   }")
  841.   
  842. ***************
  843. *** 4651,4657 ****
  844.     ""
  845.     "
  846.   {
  847. !   if (flag_pic && GET_CODE (XEXP (operands[0], 0)) == SYMBOL_REF)
  848.       operands[0] = gen_rtx (MEM, GET_MODE (operands[0]),
  849.                  force_reg (Pmode, XEXP (operands[0], 0)));
  850.   }")
  851. --- 4656,4662 ----
  852.     ""
  853.     "
  854.   {
  855. !   if (flag_pic && flag_pic < 3 && GET_CODE (XEXP (operands[0], 0)) == SYMBOL_REF)
  856.       operands[0] = gen_rtx (MEM, GET_MODE (operands[0]),
  857.                  force_reg (Pmode, XEXP (operands[0], 0)));
  858.   }")
  859. ***************
  860. *** 4662,4668 ****
  861.        (match_operand:SI 1 "general_operand" "g"))]
  862.     ;; Operand 1 not really used on the m68000.
  863.   
  864. !   "! flag_pic"
  865.     "*
  866.   #ifdef MOTOROLA
  867.     return \"jsr %0\";
  868. --- 4667,4673 ----
  869.        (match_operand:SI 1 "general_operand" "g"))]
  870.     ;; Operand 1 not really used on the m68000.
  871.   
  872. !   "(! flag_pic || flag_pic == 3)"
  873.     "*
  874.   #ifdef MOTOROLA
  875.     return \"jsr %0\";
  876. ***************
  877. *** 4677,4683 ****
  878.        (match_operand:SI 1 "general_operand" "g"))]
  879.     ;; Operand 1 not really used on the m68000.
  880.   
  881. !   "flag_pic"
  882.     "*
  883.     return \"jsr %0\";
  884.   ")
  885. --- 4682,4688 ----
  886.        (match_operand:SI 1 "general_operand" "g"))]
  887.     ;; Operand 1 not really used on the m68000.
  888.   
  889. !   "(flag_pic && flag_pic < 3)"
  890.     "*
  891.     return \"jsr %0\";
  892.   ")
  893. ***************
  894. *** 4693,4699 ****
  895.     ""
  896.     "
  897.   {
  898. !   if (flag_pic && GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF)
  899.       operands[1] = gen_rtx (MEM, GET_MODE (operands[1]),
  900.                  force_reg (Pmode, XEXP (operands[1], 0)));
  901.   }")
  902. --- 4698,4704 ----
  903.     ""
  904.     "
  905.   {
  906. !   if (flag_pic && flag_pic < 3 && GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF)
  907.       operands[1] = gen_rtx (MEM, GET_MODE (operands[1]),
  908.                  force_reg (Pmode, XEXP (operands[1], 0)));
  909.   }")
  910. ***************
  911. *** 4704,4710 ****
  912.       (call (match_operand:QI 1 "memory_operand" "o")
  913.             (match_operand:SI 2 "general_operand" "g")))]
  914.     ;; Operand 2 not really used on the m68000.
  915. !   "! flag_pic"
  916.     "*
  917.   #ifdef MOTOROLA
  918.     return \"jsr %1\";
  919. --- 4709,4715 ----
  920.       (call (match_operand:QI 1 "memory_operand" "o")
  921.             (match_operand:SI 2 "general_operand" "g")))]
  922.     ;; Operand 2 not really used on the m68000.
  923. !   "(! flag_pic || flag_pic == 3)"
  924.     "*
  925.   #ifdef MOTOROLA
  926.     return \"jsr %1\";
  927. ***************
  928. *** 4719,4725 ****
  929.       (call (match_operand:QI 1 "memory_operand" "o")
  930.             (match_operand:SI 2 "general_operand" "g")))]
  931.     ;; Operand 2 not really used on the m68000.
  932. !   "flag_pic"
  933.     "*
  934.     return \"jsr %1\";
  935.   ")
  936. --- 4724,4730 ----
  937.       (call (match_operand:QI 1 "memory_operand" "o")
  938.             (match_operand:SI 2 "general_operand" "g")))]
  939.     ;; Operand 2 not really used on the m68000.
  940. !   "(flag_pic && flag_pic < 3)"
  941.     "*
  942.     return \"jsr %1\";
  943.   ")
  944. diff -c -r ngcc/cp-tree.c gcc/cp-tree.c
  945. *** ngcc/cp-tree.c    Mon Nov 30 15:34:32 1992
  946. --- gcc/cp-tree.c    Mon Dec 28 00:27:36 1992
  947. ***************
  948. *** 1698,1703 ****
  949. --- 1698,1704 ----
  950.     print_class_statistics ();
  951.   }
  952.   
  953. + #ifndef atarist
  954.   /* This is used by the `assert' macro.  It is provided in libgcc.a,
  955.      which `cc' doesn't know how to link.  Note that the C++ front-end
  956.      no longer actually uses the `assert' macro (instead, it calls
  957. ***************
  958. *** 1720,1725 ****
  959. --- 1721,1727 ----
  960.     fflush (stderr);
  961.     abort ();
  962.   }
  963. + #endif
  964.   
  965.   /* Return, as an INTEGER_CST node, the number of elements for
  966.      TYPE (which is an ARRAY_TYPE).  This counts only elements of the top array. */
  967. diff -c -r ngcc/expr.c gcc/expr.c
  968. *** ngcc/expr.c    Mon Nov 30 15:34:53 1992
  969. --- gcc/expr.c    Mon Dec 28 00:27:39 1992
  970. ***************
  971. *** 1977,1982 ****
  972. --- 1977,1988 ----
  973.   
  974.     argvec = (struct arg *) alloca (nargs * sizeof (struct arg));
  975.   
  976. + /* how would you do this RIGHT ?? fake a DECL node? dunno... */
  977. + #ifdef ENCODE_SECTION_INFO
  978. +   /* mark it as a function (to be in the text section that is) */
  979. +   SYMBOL_REF_FLAG (fun) = 1;
  980. + #endif
  981. + 
  982.     INIT_CUMULATIVE_ARGS (args_so_far, (tree)0, fun);
  983.   
  984.     args_size.constant = 0;
  985. diff -c -r ngcc/final.c gcc/final.c
  986. *** ngcc/final.c    Mon Nov 30 15:35:01 1992
  987. --- gcc/final.c    Mon Dec 28 00:27:42 1992
  988. ***************
  989. *** 67,74 ****
  990. --- 67,78 ----
  991.   #if defined (USG) || defined (NO_STAB_H)
  992.   #include "gstab.h"  /* If doing DBX on sysV, use our own stab.h.  */
  993.   #else
  994. + #if defined(CROSSATARI) || defined(atarist) || defined(atariminix)
  995. + #include "astab.h"
  996. + #else
  997.   #include <stab.h>  /* On BSD, use the system's stab.h.  */
  998.   #endif /* not USG */
  999. + #endif /* not atari */
  1000.   #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
  1001.   
  1002.   #ifdef XCOFF_DEBUGGING_INFO
  1003. diff -c -r ngcc/fold-const.c gcc/fold-const.c
  1004. *** ngcc/fold-const.c    Mon Nov 30 15:35:07 1992
  1005. --- gcc/fold-const.c    Mon Dec 28 00:27:45 1992
  1006. ***************
  1007. *** 62,68 ****
  1008.   #define left_shift_overflows(a, b)  ((a)  !=  ((a) << (b)) >> (b))
  1009.   
  1010.   /* Yield nonzero if A and B have the same sign.  */
  1011. ! #define same_sign(a, b) ((a) ^ (b) >= 0)
  1012.   
  1013.   /* Suppose A1 + B1 = SUM1, using 2's complement arithmetic ignoring overflow.
  1014.      Suppose A, B and SUM have the same respective signs as A1, B1, and SUM1.
  1015. --- 62,68 ----
  1016.   #define left_shift_overflows(a, b)  ((a)  !=  ((a) << (b)) >> (b))
  1017.   
  1018.   /* Yield nonzero if A and B have the same sign.  */
  1019. ! #define same_sign(a, b) (((a) ^ (b)) >= 0)
  1020.   
  1021.   /* Suppose A1 + B1 = SUM1, using 2's complement arithmetic ignoring overflow.
  1022.      Suppose A, B and SUM have the same respective signs as A1, B1, and SUM1.
  1023. diff -c -r ngcc/gcc.c gcc/gcc.c
  1024. *** ngcc/gcc.c    Mon Dec 28 00:44:57 1992
  1025. --- gcc/gcc.c    Mon Dec 28 00:27:50 1992
  1026. ***************
  1027. *** 30,35 ****
  1028. --- 30,44 ----
  1029.   Once it knows which kind of compilation to perform, the procedure for
  1030.   compilation is specified by a string called a "spec".  */
  1031.   
  1032. + #ifdef CROSSATARI
  1033. + #ifdef atarist
  1034. + #undef atarist
  1035. + #endif
  1036. + #ifdef atariminix
  1037. + #undef atariminix
  1038. + #endif
  1039. + #endif
  1040. +   
  1041.   #include <sys/types.h>
  1042.   #include <ctype.h>
  1043.   #include <signal.h>
  1044. ***************
  1045. *** 40,45 ****
  1046. --- 49,57 ----
  1047.   #include "obstack.h"
  1048.   #include "gvarargs.h"
  1049.   #include <stdio.h>
  1050. + #ifdef CROSSATARI
  1051. + #include <ctype.h>
  1052. + #endif
  1053.   
  1054.   #ifndef R_OK
  1055.   #define R_OK 4
  1056. ***************
  1057. *** 65,71 ****
  1058.   #define NULL_PTR ((GENERIC_PTR)0)
  1059.   #endif
  1060.   
  1061. ! #ifdef USG
  1062.   #define vfork fork
  1063.   #endif /* USG */
  1064.   
  1065. --- 77,83 ----
  1066.   #define NULL_PTR ((GENERIC_PTR)0)
  1067.   #endif
  1068.   
  1069. ! #if (defined(USG) || defined(atariminix))
  1070.   #define vfork fork
  1071.   #endif /* USG */
  1072.   
  1073. ***************
  1074. *** 97,102 ****
  1075. --- 109,121 ----
  1076.   #define PATH_SEPARATOR ':'
  1077.   #endif
  1078.   
  1079. + #ifdef atarist
  1080. + #include <osbind.h>
  1081. + #include <ctype.h>
  1082. + #include <fcntl.h>        /* fgth, for redirection of stderr */
  1083. + long _stksize = 8192;
  1084. + #endif
  1085. + 
  1086.   #define obstack_chunk_alloc xmalloc
  1087.   #define obstack_chunk_free free
  1088.   
  1089. ***************
  1090. *** 153,159 ****
  1091. --- 172,180 ----
  1092.      pass the compiler in building the list of pointers to constructors
  1093.      and destructors.  */
  1094.   
  1095. + #if (!(defined(CROSSATARI) || defined(atarist)))
  1096.   static struct obstack collect_obstack;
  1097. + #endif
  1098.   
  1099.   extern char *version_string;
  1100.   
  1101. ***************
  1102. *** 445,451 ****
  1103.              %{aux-info*}\
  1104.              %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  1105.              %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  1106. !               %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
  1107.                 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  1108.                         %{!pipe:%g.s} %A\n }}}}"},
  1109.     {"-",
  1110. --- 466,472 ----
  1111.              %{aux-info*}\
  1112.              %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  1113.              %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  1114. !               %{!S:as %{v} %{R} %{j} %{J} %{h} %{d2} %a %Y\
  1115.                 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  1116.                         %{!pipe:%g.s} %A\n }}}}"},
  1117.     {"-",
  1118. ***************
  1119. *** 478,484 ****
  1120.              %{aux-info*}\
  1121.              %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  1122.              %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  1123. !               %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
  1124.                 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  1125.                         %{!pipe:%g.s} %A\n }}}}"},
  1126.     {".h", "@c-header"},
  1127. --- 499,505 ----
  1128.              %{aux-info*}\
  1129.              %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  1130.              %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  1131. !               %{!S:as %{v} %{R} %{j} %{J} %{h} %{d2} %a %Y\
  1132.                 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  1133.                         %{!pipe:%g.s} %A\n }}}}"},
  1134.     {".h", "@c-header"},
  1135. ***************
  1136. *** 513,519 ****
  1137.              %{aux-info*}\
  1138.              %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  1139.              %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  1140. !               %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
  1141.                 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  1142.                         %{!pipe:%g.s} %A\n }}}}"},
  1143.     {".i", "@cpp-output"},
  1144. --- 534,540 ----
  1145.              %{aux-info*}\
  1146.              %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  1147.              %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  1148. !               %{!S:as %{v} %{R} %{j} %{J} %{h} %{d2} %a %Y\
  1149.                 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  1150.                         %{!pipe:%g.s} %A\n }}}}"},
  1151.     {".i", "@cpp-output"},
  1152. ***************
  1153. *** 524,530 ****
  1154.       %{aux-info*}\
  1155.       %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  1156.       %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  1157. !     %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
  1158.               %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o} %{!pipe:%g.s} %A\n }"},
  1159.     {".ii", "@c++-cpp-output"},
  1160.     {"@c++-cpp-output",
  1161. --- 545,551 ----
  1162.       %{aux-info*}\
  1163.       %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  1164.       %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  1165. !     %{!S:as %{v} %{R} %{j} %{J} %{h} %{d2} %a %Y\
  1166.               %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o} %{!pipe:%g.s} %A\n }"},
  1167.     {".ii", "@c++-cpp-output"},
  1168.     {"@c++-cpp-output",
  1169. ***************
  1170. *** 534,547 ****
  1171.           %{aux-info*}\
  1172.           %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  1173.           %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  1174. !        %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
  1175.              %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  1176.              %{!pipe:%g.s} %A\n }"},
  1177.     {".s", "@assembler"},
  1178.     {"@assembler",
  1179. !    "%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
  1180.               %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o} %i %A\n }"},
  1181.     {".S", "@assembler-with-cpp"},
  1182.     {"@assembler-with-cpp",
  1183.      "cpp -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
  1184.       %{C:%{!E:%eGNU C does not support -C without using -E}}\
  1185. --- 555,571 ----
  1186.           %{aux-info*}\
  1187.           %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  1188.           %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  1189. !        %{!S:as %{v} %{R} %{j} %{J} %{h} %{d2} %a %Y\
  1190.              %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  1191.              %{!pipe:%g.s} %A\n }"},
  1192.     {".s", "@assembler"},
  1193.     {"@assembler",
  1194. !    "%{!S:as %{v} %{R} %{j} %{J} %{h} %{d2} %a %Y\
  1195.               %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o} %i %A\n }"},
  1196.     {".S", "@assembler-with-cpp"},
  1197. +   {".ss", "@assembler-with-cpp"},
  1198. +   {".cpp", "@assembler-with-cpp"},
  1199. +   {".spp", "@assembler-with-cpp"},
  1200.     {"@assembler-with-cpp",
  1201.      "cpp -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{I*} %{P} %I\
  1202.       %{C:%{!E:%eGNU C does not support -C without using -E}}\
  1203. ***************
  1204. *** 551,557 ****
  1205.           %{traditional-cpp:-traditional}\
  1206.       %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
  1207.           %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
  1208. !    "%{!M:%{!MM:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
  1209.                       %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  1210.               %{!pipe:%g.s} %A\n }}}}"},
  1211.     /* Mark end of table */
  1212. --- 575,581 ----
  1213.           %{traditional-cpp:-traditional}\
  1214.       %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\
  1215.           %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
  1216. !    "%{!M:%{!MM:%{!E:%{!S:as %{v} %{R} %{j} %{J} %{h} %{d2} %a %Y\
  1217.                       %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  1218.               %{!pipe:%g.s} %A\n }}}}"},
  1219.     /* Mark end of table */
  1220. ***************
  1221. *** 565,570 ****
  1222. --- 589,602 ----
  1223.   
  1224.   /* Here is the spec for running the linker, after compiling all files.  */
  1225.   
  1226. + #if (defined(CROSSATARI) || defined(atarist) || defined(atariminix))
  1227. + static char *link_command_spec = 
  1228. +  "%{!c:%{!M*:%{!E:%{!S:ld %X %{v} %{G} %{o*} %l\
  1229. +  %{A} %{d} %{e*} %{N} %{n} %{r} %{s} %{S} %{T*} %{t} %{u*} %{X} %{x} %{z}\
  1230. +  %{y*} %{!nostdlib:%S} \
  1231. +  %{L*} %o %{!nostdlib:%s %L}\n }}}}";
  1232. + 
  1233. + #else
  1234.   /* -u* was put back because both BSD and SysV seem to support it.  */
  1235.   /* %{static:} simply prevents an error message if the target machine
  1236.      doesn't handle -static.  */
  1237. ***************
  1238. *** 592,597 ****
  1239. --- 624,630 ----
  1240.               %{L*} %D %o %{!nostdlib:-lgcc %L -lgcc %{!A:%E}}\n }}}}}";
  1241.   #endif
  1242.   #endif
  1243. + #endif
  1244.   
  1245.   /* A vector of options to give to the linker.
  1246.      These options are accumulated by -Xlinker and -Wl,
  1247. ***************
  1248. *** 605,610 ****
  1249. --- 638,644 ----
  1250.   static int n_assembler_options;
  1251.   static char **assembler_options;
  1252.   
  1253. + #if (!(defined(atarist) || defined(CROSSATARI) || defined(atariminix)))
  1254.   /* Read compilation specs from a file named FILENAME,
  1255.      replacing the default ones.
  1256.   
  1257. ***************
  1258. *** 743,748 ****
  1259. --- 777,783 ----
  1260.   
  1261.     return p;
  1262.   }
  1263. + #endif /* ataris */
  1264.   
  1265.   /* Structure to keep track of the specs that have been defined so far.  These
  1266.      are accessed using %(specname) or %[specname] in a compiler or link spec. */
  1267. ***************
  1268. *** 859,864 ****
  1269. --- 894,906 ----
  1270.   /* Name with which this program was invoked.  */
  1271.   
  1272.   static char *programname;
  1273. + 
  1274. + #ifdef atarist
  1275. + /* Flag indicating, that stderr should be redirected for the child
  1276. +    processes */
  1277. + 
  1278. + unsigned char zflag;
  1279. + #endif
  1280.   
  1281.   /* Structures to keep track of prefixes to try when looking for files. */
  1282.   
  1283. ***************
  1284. *** 1115,1122 ****
  1285.   static void
  1286.   choose_temp_base ()
  1287.   {
  1288. -   char *base = getenv ("TMPDIR");
  1289.     int len;
  1290.   
  1291.     if (base == (char *)0)
  1292.       {
  1293. --- 1157,1181 ----
  1294.   static void
  1295.   choose_temp_base ()
  1296.   {
  1297.     int len;
  1298. + #if (!(defined(atarist) || defined(atariminix)))
  1299. +   char *base = getenv ("TMPDIR");
  1300. + #else
  1301. +   char *base = getenv ("TEMP");
  1302. + 
  1303. +   if(base == (char *)0)
  1304. +   {
  1305. +       base = getenv("TMPDIR");
  1306. +       if(base == (char *)0)
  1307. +       base = getenv("TMP");
  1308. +   }
  1309. +   if(base != (char *)0)
  1310. +   {
  1311. +       char *newbase = alloca(FILENAME_MAX);
  1312. +       dos2unx(base,newbase);
  1313. +       base = newbase;
  1314. +   }
  1315. + #endif
  1316.   
  1317.     if (base == (char *)0)
  1318.       {
  1319. ***************
  1320. *** 1136,1142 ****
  1321.     len = strlen (base);
  1322.     temp_filename = xmalloc (len + sizeof("/ccXXXXXX"));
  1323.     strcpy (temp_filename, base);
  1324. !   if (len > 0 && temp_filename[len-1] != '/')
  1325.       temp_filename[len++] = '/';
  1326.     strcpy (temp_filename + len, "ccXXXXXX");
  1327.   
  1328. --- 1195,1205 ----
  1329.     len = strlen (base);
  1330.     temp_filename = xmalloc (len + sizeof("/ccXXXXXX"));
  1331.     strcpy (temp_filename, base);
  1332. !   if (len > 0 && (temp_filename[len-1] != '/' 
  1333. ! #ifdef atarist
  1334. !           || temp_filename[len-1] != '\\'
  1335. ! #endif
  1336. !            ))
  1337.       temp_filename[len++] = '/';
  1338.     strcpy (temp_filename + len, "ccXXXXXX");
  1339.   
  1340. ***************
  1341. *** 1155,1160 ****
  1342. --- 1218,1224 ----
  1343.      use come from an obstack, we don't have to worry about allocating
  1344.      space for them.  */
  1345.   
  1346. + #if (!(defined(CROSSATARI) || defined(atarist)))
  1347.   #ifndef HAVE_PUTENV
  1348.   
  1349.   putenv (str)
  1350. ***************
  1351. *** 1249,1254 ****
  1352. --- 1313,1319 ----
  1353.     obstack_grow (&collect_obstack, "\0", 1);
  1354.     putenv (obstack_finish (&collect_obstack));
  1355.   }
  1356. + #endif /* ataris */
  1357.   
  1358.   
  1359.   /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
  1360. ***************
  1361. *** 1524,1529 ****
  1362. --- 1589,1595 ----
  1363.   
  1364.   #else /* not __MSDOS__ */
  1365.   
  1366. + #ifndef atarist
  1367.   static int
  1368.   pexecute (search_flag, program, argv, not_last)
  1369.        int search_flag;
  1370. ***************
  1371. *** 1612,1617 ****
  1372. --- 1678,1684 ----
  1373.       }
  1374.   }
  1375.   
  1376. + #endif /* not atarist */
  1377.   #endif /* not __MSDOS__ */
  1378.   #else /* not OS2 */
  1379.   
  1380. ***************
  1381. *** 1642,1657 ****
  1382.       {
  1383.         char *prog;        /* program name.  */
  1384.         char **argv;        /* vector of args.  */
  1385.         int pid;            /* pid of process for this command.  */
  1386.       };
  1387.   
  1388.     struct command *commands;    /* each command buffer with above info.  */
  1389.   
  1390.     /* Count # of piped commands.  */
  1391.     for (n_commands = 1, i = 0; i < argbuf_index; i++)
  1392.       if (strcmp (argbuf[i], "|") == 0)
  1393.         n_commands++;
  1394. ! 
  1395.     /* Get storage for each command.  */
  1396.     commands
  1397.       = (struct command *) alloca (n_commands * sizeof (struct command));
  1398. --- 1709,1729 ----
  1399.       {
  1400.         char *prog;        /* program name.  */
  1401.         char **argv;        /* vector of args.  */
  1402. + #ifndef atarist
  1403.         int pid;            /* pid of process for this command.  */
  1404. + #endif
  1405.       };
  1406.   
  1407.     struct command *commands;    /* each command buffer with above info.  */
  1408.   
  1409. + #ifndef atarist
  1410.     /* Count # of piped commands.  */
  1411.     for (n_commands = 1, i = 0; i < argbuf_index; i++)
  1412.       if (strcmp (argbuf[i], "|") == 0)
  1413.         n_commands++;
  1414. ! #else
  1415. !   n_commands = 1;
  1416. ! #endif
  1417.     /* Get storage for each command.  */
  1418.     commands
  1419.       = (struct command *) alloca (n_commands * sizeof (struct command));
  1420. ***************
  1421. *** 1666,1671 ****
  1422. --- 1738,1744 ----
  1423.     if (string)
  1424.       commands[0].argv[0] = string;
  1425.   
  1426. + #ifndef atarist
  1427.     for (n_commands = 1, i = 0; i < argbuf_index; i++)
  1428.       if (strcmp (argbuf[i], "|") == 0)
  1429.         {                /* each command.  */
  1430. ***************
  1431. *** 1680,1685 ****
  1432. --- 1753,1761 ----
  1433.         commands[n_commands].argv[0] = string;
  1434.       n_commands++;
  1435.         }
  1436. + #else
  1437. +   n_commands = 1;
  1438. + #endif
  1439.   
  1440.     argbuf[argbuf_index] = 0;
  1441.   
  1442. ***************
  1443. *** 1695,1703 ****
  1444. --- 1771,1781 ----
  1445.         for (j = commands[i].argv; *j; j++)
  1446.           fprintf (stderr, " %s", *j);
  1447.   
  1448. + #ifndef atarist
  1449.         /* Print a pipe symbol after all but the last command.  */
  1450.         if (i + 1 != n_commands)
  1451.           fprintf (stderr, " |");
  1452. + #endif
  1453.         fprintf (stderr, "\n");
  1454.       }
  1455.         fflush (stderr);
  1456. ***************
  1457. *** 1712,1722 ****
  1458. --- 1790,1802 ----
  1459.   #endif /* DEBUG */
  1460.       }
  1461.   
  1462. + #ifndef atarist
  1463.     /* Run each piped subprocess.  */
  1464.   
  1465.     last_pipe_input = STDIN_FILE_NO;
  1466.     for (i = 0; i < n_commands; i++)
  1467.       {
  1468. + #ifndef atariminix
  1469.         char *string = commands[i].argv[0];
  1470.   
  1471.         commands[i].pid = pexecute (string != commands[i].prog,
  1472. ***************
  1473. *** 1723,1728 ****
  1474. --- 1803,1816 ----
  1475.                     string, commands[i].argv,
  1476.                     i + 1 < n_commands);
  1477.   
  1478. + #else
  1479. +       extern int execv();
  1480. +       char *string = commands[i].argv[0];
  1481. + 
  1482. +       commands[i].pid = pexecute (execv,
  1483. +                   string, commands[i].argv,
  1484. +                   i + 1 < n_commands);
  1485. + #endif
  1486.         if (string != commands[i].prog)
  1487.       free (string);
  1488.       }
  1489. ***************
  1490. *** 1769,1774 ****
  1491. --- 1857,1907 ----
  1492.         }
  1493.       return ret_code;
  1494.     }
  1495. + #else /* atarist */
  1496. +  {
  1497. +      register int iii;
  1498. +      int errfd, oldfd;
  1499. +      char **j;
  1500. + 
  1501. +      execution_count++;
  1502. + 
  1503. +      if (zflag)
  1504. +        {
  1505. +      errfd = Fopen("compile.err", 2);
  1506. +      if (errfd < __SMALLEST_VALID_HANDLE)
  1507. +        errfd = Fcreate("compile.err", 0);
  1508. +      else
  1509. +        Fseek(0L, errfd, 2);
  1510. +      if (errfd >= __SMALLEST_VALID_HANDLE)
  1511. +        {
  1512. +          oldfd = Fdup (2);
  1513. +          Fforce(2, errfd);
  1514. +        }
  1515. +      else
  1516. +        {
  1517. +          error("cannot open %s", "compile.err");
  1518. +          zflag = 0;        /* no redirection */
  1519. +        }
  1520. +        }
  1521. +      for (i = 0; i < n_commands ; i++)
  1522. +      {
  1523. +          j = commands[i].argv;
  1524. +          iii = spawnve(0, j[0], j, NULL);
  1525. +      if(iii != 0)
  1526. +          break;
  1527. +      }
  1528. +      if (zflag)
  1529. +        {
  1530. +      Fforce(2, oldfd);
  1531. +      Fclose(oldfd);
  1532. +      Fclose(errfd);
  1533. +        }
  1534. +      if (iii != 0)
  1535. +        return -1;
  1536. +      else
  1537. +        return 0;
  1538. +  }
  1539. + #endif /* atarist */  
  1540.   }
  1541.   
  1542.   /* Find all the switches given to us
  1543. ***************
  1544. *** 1832,1837 ****
  1545. --- 1965,1971 ----
  1546.   
  1547.     /* Set up the default search paths.  */
  1548.   
  1549. + #ifndef CROSSATARI
  1550.     if (gcc_exec_prefix)
  1551.       {
  1552.         add_prefix (&exec_prefix, gcc_exec_prefix, 0, 0, NULL_PTR);
  1553. ***************
  1554. *** 1908,1913 ****
  1555. --- 2042,2048 ----
  1556.           endp++;
  1557.       }
  1558.       }
  1559. + #endif /* CROSSATARI */
  1560.   
  1561.     /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
  1562.     temp = getenv ("LPATH");
  1563. ***************
  1564. *** 2115,2120 ****
  1565. --- 2250,2261 ----
  1566.             n_switches++;
  1567.             break;
  1568.           }
  1569. + #ifdef atarist
  1570. +         case 'z':    /* redirect stderr to a file */
  1571. +           zflag++;
  1572. +           n_switches++;
  1573. +           break;
  1574. + #endif
  1575.           default:
  1576.             n_switches++;
  1577.   
  1578. ***************
  1579. *** 2134,2144 ****
  1580. --- 2275,2296 ----
  1581.        (such as cpp) rather than those of the host system.  */
  1582.     /* Use 2 as fourth arg meaning try just the machine as a suffix,
  1583.        as well as trying the machine and the version.  */
  1584. + #if (defined(atarist) || defined(CROSSATARI) || defined(WEIRD))
  1585. + /* NB defined(WEIRD) should not really be there, its only for my weird setup */
  1586. +   /* We are not using machine_suffix here, so do not make */
  1587. +   /* these prefixes available only when we have one       */
  1588. +   add_prefix (&exec_prefix, standard_exec_prefix, 0, 0, NULL_PTR);
  1589. +   add_prefix (&exec_prefix, standard_exec_prefix_1, 0, 0, NULL_PTR);
  1590. + 
  1591. +   add_prefix (&startfile_prefix, standard_exec_prefix, 0, 0, NULL_PTR);
  1592. +   add_prefix (&startfile_prefix, standard_exec_prefix_1, 0, 0, NULL_PTR);
  1593. + #else
  1594.     add_prefix (&exec_prefix, standard_exec_prefix, 0, 2, NULL_PTR);
  1595.     add_prefix (&exec_prefix, standard_exec_prefix_1, 0, 2, NULL_PTR);
  1596.   
  1597.     add_prefix (&startfile_prefix, standard_exec_prefix, 0, 1, NULL_PTR);
  1598.     add_prefix (&startfile_prefix, standard_exec_prefix_1, 0, 1, NULL_PTR);
  1599. + #endif /* (defined(atarist) || defined(CROSSATARI)) */
  1600.   
  1601.     /* More prefixes are enabled in main, after we read the specs file
  1602.        and determine whether this is cross-compilation or not.  */
  1603. ***************
  1604. *** 2306,2311 ****
  1605. --- 2458,2472 ----
  1606.      search dirs for it.  */
  1607.   static int this_is_library_file;
  1608.   
  1609. + #ifdef atarist
  1610. + /* I don't know why this is necessary.  Recursive calls to do_spec_1
  1611. +    end up ignoring the error code from calls to execute().  That causes
  1612. +    do_spec to get a 0 return value, and do_spec_1("\n"), which causes the
  1613. +    command to get executed again.
  1614. + */
  1615. + int execute_return_error = 0;
  1616. + #endif
  1617. + 
  1618.   /* Process the spec SPEC and run the commands specified therein.
  1619.      Returns 0 if the spec is successfully processed; -1 if failed.  */
  1620.   
  1621. ***************
  1622. *** 2325,2334 ****
  1623. --- 2486,2504 ----
  1624.   
  1625.     /* Force out any unfinished command.
  1626.        If -pipe, this forces out the last command if it ended in `|'.  */
  1627. + #ifdef atarist
  1628. +   if (!value && execute_return_error)
  1629. +     {
  1630. +     value = execute_return_error;
  1631. +     execute_return_error = 0;
  1632. +     }
  1633. + #endif
  1634.     if (value == 0)
  1635.       {
  1636. + #ifndef atarist
  1637.         if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
  1638.       argbuf_index--;
  1639. + #endif
  1640.   
  1641.         if (argbuf_index > 0)
  1642.       value = execute ();
  1643. ***************
  1644. *** 2365,2370 ****
  1645. --- 2535,2591 ----
  1646.          Otherwise, NL, SPC, TAB and % are special.  */
  1647.       switch (inswitch ? 'a' : c)
  1648.         {
  1649. + #if (defined(atarist) || defined(CROSSATARI))
  1650. + /* this stuff added by jrd.  if see '$', expect name of env var, delimited
  1651. +    by '$'.  Find it's value, and subst it in.
  1652. + 
  1653. +    modified by ERS to only collect things that look like names; this
  1654. +    saves e.g. the -$ arg. to cpp from getting munged */
  1655. + 
  1656. +       case '$':
  1657. +       {
  1658. +     char varname[32];        /* should be enough */
  1659. +     char * value;            /* deciphered value string */
  1660. +     char *temp;
  1661. +     int i;
  1662. +     extern char *getenv(), *index();
  1663. +     
  1664. +     for (i = 0 ; ((c = *p) != '$') && isalnum(c) && i < 31 ; i++, p++)
  1665. +         varname[i] = c;
  1666. +     varname[i] = '\0';
  1667. +     if (strlen(varname) > 0) /* ++jrb fix */
  1668. +     {
  1669. +                  ++p;    /* skip trailing '$' */
  1670. +         value = getenv(varname); /* ++jrb fix */
  1671. +         if (value)
  1672. +         { /* if value is a path, only consider 1'st component */
  1673. + #ifdef atarist
  1674. +             if((temp = index(value, ',')) == NULL)
  1675. +                 temp = index(value, ';');
  1676. + #else
  1677. +             temp = index(value, ':');
  1678. + #endif
  1679. +             if(temp != NULL)
  1680. +             {
  1681. +                 char *t = (char *) alloca(strlen(value) + 1);
  1682. +                 strcpy(t, value);
  1683. +                 t[temp-value] = '\0';
  1684. +                 do_spec_1(t, 0);
  1685. +             }
  1686. +             else
  1687. +                 do_spec_1(value, 0);
  1688. +         }
  1689. +             else
  1690. +             do_spec_1(".", 0);    /* a compleat kludge... */
  1691. +     }
  1692. +         else
  1693. +         {
  1694. +              obstack_1grow(&obstack, '$');
  1695. +              arg_going = 1;
  1696. +         }
  1697. +       }
  1698. +      break;
  1699. + #endif /* atarist */
  1700.         case '\n':
  1701.       /* End of line: finish any pending argument,
  1702.          then run the pending command if one has been started.  */
  1703. ***************
  1704. *** 2402,2407 ****
  1705. --- 2623,2632 ----
  1706.       if (argbuf_index > 0)
  1707.         {
  1708.           int value = execute ();
  1709. + #ifdef atarist
  1710. +         if (!execute_return_error)
  1711. +             execute_return_error = value;
  1712. + #endif
  1713.           if (value)
  1714.             return value;
  1715.         }
  1716. ***************
  1717. *** 2985,2997 ****
  1718. --- 3210,3230 ----
  1719.           break;
  1720.   
  1721.         default:
  1722. + #if 1 /* atarist */
  1723. +         fprintf(stderr, "Bogus char '%c' found at pos %d of spec '%s'\n",
  1724. +         c, (p - spec - 1), spec);
  1725. + #endif
  1726.           abort ();
  1727.         }
  1728.       break;
  1729.   
  1730. + #ifndef atarist
  1731. +       /* on the atari it is important to preserve backslash in spec */
  1732. +       /* so just let it go into default case */
  1733.         case '\\':
  1734.       /* Backslash: treat next character as ordinary.  */
  1735.       c = *p++;
  1736. + #endif
  1737.   
  1738.       /* fall through */
  1739.         default:
  1740. ***************
  1741. *** 3259,3264 ****
  1742. --- 3492,3498 ----
  1743.   
  1744.   /* On fatal signals, delete all the temporary files.  */
  1745.   
  1746. + #ifndef atarist
  1747.   static void
  1748.   fatal_error (signum)
  1749.        int signum;
  1750. ***************
  1751. *** 3270,3275 ****
  1752. --- 3504,3510 ----
  1753.        so its normal effect occurs.  */
  1754.     kill (getpid (), signum);
  1755.   }
  1756. + #endif
  1757.   
  1758.   int
  1759.   main (argc, argv)
  1760. ***************
  1761. *** 3284,3289 ****
  1762. --- 3519,3529 ----
  1763.     char *explicit_link_files;
  1764.     char *specs_file;
  1765.   
  1766. + #ifdef atarist
  1767. + /* turn this on if you are going to set the TOS 1.4 dont clear heap flag */
  1768. + /*  _malloczero(1); */     /* zero mallocs by default */
  1769. +   programname = "gcc";
  1770. + #else  
  1771.     programname = argv[0];
  1772.   
  1773.     if (signal (SIGINT, SIG_IGN) != SIG_IGN)
  1774. ***************
  1775. *** 3296,3301 ****
  1776. --- 3536,3542 ----
  1777.     if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
  1778.       signal (SIGPIPE, fatal_error);
  1779.   #endif
  1780. + #endif /* atarist */
  1781.   
  1782.     argbuf_length = 10;
  1783.     argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
  1784. ***************
  1785. *** 3302,3307 ****
  1786. --- 3543,3549 ----
  1787.   
  1788.     obstack_init (&obstack);
  1789.   
  1790. + #if (!(defined(atarist) || defined(CROSSATARI)))
  1791.     /* Set up to remember the pathname of gcc and any options
  1792.        needed for collect.  */
  1793.     obstack_init (&collect_obstack);
  1794. ***************
  1795. *** 3308,3313 ****
  1796. --- 3550,3556 ----
  1797.     obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=")-1);
  1798.     obstack_grow (&collect_obstack, programname, strlen (programname)+1);
  1799.     putenv (obstack_finish (&collect_obstack));
  1800. + #endif
  1801.   
  1802.     /* Choose directory for temp files.  */
  1803.   
  1804. ***************
  1805. *** 3319,3324 ****
  1806. --- 3562,3576 ----
  1807.   
  1808.     process_command (argc, argv);
  1809.   
  1810. + #if (defined(atarist) || defined(CROSSATARI))
  1811. +   {
  1812. +     char *temp;
  1813. +     
  1814. +     if((temp = getenv ("GCCEXEC")))
  1815. +     add_prefix (&exec_prefix, temp, 0, 0, 0);
  1816. +   }
  1817. + #endif
  1818. +   
  1819.     /* Initialize the vector of specs to just the default.
  1820.        This means one element containing 0s, as a terminator.  */
  1821.   
  1822. ***************
  1823. *** 3326,3331 ****
  1824. --- 3578,3587 ----
  1825.     bcopy (default_compilers, compilers, sizeof default_compilers);
  1826.     n_compilers = n_default_compilers;
  1827.   
  1828. + 
  1829. + #if (defined(atarist) || defined(CROSSATARI) || defined(atariminix))
  1830. +   specs_file = 0;
  1831. + #else
  1832.     /* Read specs from a file if there is one.  */
  1833.   
  1834.     machine_suffix = concat (spec_machine, "/", concat (spec_version, "/", ""));
  1835. ***************
  1836. *** 3335,3340 ****
  1837. --- 3591,3597 ----
  1838.     /* Read the specs file unless it is a default one.  */
  1839.     if (specs_file != 0 && strcmp (specs_file, "specs"))
  1840.       read_specs (specs_file);
  1841. + #endif
  1842.   
  1843.     /* If not cross-compiling, look for startfiles in the standard places.  */
  1844.     /* The fact that these are done here, after reading the specs file,
  1845. ***************
  1846. *** 3387,3393 ****
  1847. --- 3644,3656 ----
  1848.   
  1849.     if (verbose_flag)
  1850.       {
  1851. + #if (defined(atarist) || defined(CROSSATARI) || defined(atariminix))
  1852. + #include "PatchLev.h"
  1853. +       fprintf (stderr, "gcc-atariST version %s Patchlevel %s\n",
  1854. +            version_string, PatchLevel);
  1855. + #else
  1856.         fprintf (stderr, "gcc version %s\n", version_string);
  1857. + #endif
  1858.         if (n_infiles == 0)
  1859.       exit (0);
  1860.       }
  1861. ***************
  1862. *** 3435,3441 ****
  1863. --- 3698,3709 ----
  1864.   
  1865.         input_basename = input_filename;
  1866.         for (p = input_filename; *p; p++)
  1867. + #ifdef atarist
  1868. +         if (((*p == '/') || (*p == '\\')) && (*(p-1) != ':'))
  1869. +             /* allow both '\' and '/' with  our new lib */
  1870. + #else
  1871.           if (*p == '/')
  1872. + #endif
  1873.             input_basename = p + 1;
  1874.   
  1875.         /* Find a suffix starting with the last period,
  1876. ***************
  1877. *** 3498,3503 ****
  1878. --- 3766,3772 ----
  1879.         int i;
  1880.         int first_time;
  1881.   
  1882. + #if (!(defined(atarist) || defined(CROSSATARI)))
  1883.         /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
  1884.        for collect.  */
  1885.         putenv_from_prefixes (&exec_prefix, "COMPILER_PATH=");
  1886. ***************
  1887. *** 3528,3533 ****
  1888. --- 3797,3803 ----
  1889.       }
  1890.         obstack_grow (&collect_obstack, "\0", 1);
  1891.         putenv (obstack_finish (&collect_obstack));
  1892. + #endif
  1893.   
  1894.         value = do_spec (link_command_spec);
  1895.         if (value < 0)
  1896. diff -c -r ngcc/getpwd.c gcc/getpwd.c
  1897. *** ngcc/getpwd.c    Mon Dec 28 00:45:00 1992
  1898. --- gcc/getpwd.c    Mon Dec 28 00:27:53 1992
  1899. ***************
  1900. *** 14,20 ****
  1901.      BSD systems) now provides getcwd as called for by POSIX.  Allow for
  1902.      the few exceptions to the general rule here.  */
  1903.   
  1904. ! #if !(defined (POSIX) || defined (USG) || defined (VMS))
  1905.   #include <sys/param.h>
  1906.   extern char *getwd ();
  1907.   #define getcwd(buf,len) getwd(buf)
  1908. --- 14,20 ----
  1909.      BSD systems) now provides getcwd as called for by POSIX.  Allow for
  1910.      the few exceptions to the general rule here.  */
  1911.   
  1912. ! #if !(defined (POSIX) || defined (USG) || defined (VMS) || defined(atarist) || defined(CROSSHPUX))
  1913.   #include <sys/param.h>
  1914.   extern char *getwd ();
  1915.   #define getcwd(buf,len) getwd(buf)
  1916. ***************
  1917. *** 48,58 ****
  1918.     if (!p && !(errno = failure_errno))
  1919.       {
  1920.         if (! ((p = getenv ("PWD")) != 0
  1921.            && *p == '/'
  1922.            && stat (p, &pwdstat) == 0
  1923.            && stat (".", &dotstat) == 0
  1924.            && dotstat.st_ino == pwdstat.st_ino
  1925. !          && dotstat.st_dev == pwdstat.st_dev))
  1926.   
  1927.       /* The shortcut didn't work.  Try the slow, ``sure'' way.  */
  1928.       for (s = GUESSPATHLEN;  ! getcwd (p = xmalloc (s), s);  s *= 2)
  1929. --- 48,61 ----
  1930.     if (!p && !(errno = failure_errno))
  1931.       {
  1932.         if (! ((p = getenv ("PWD")) != 0
  1933. + #ifndef atarist
  1934.            && *p == '/'
  1935.            && stat (p, &pwdstat) == 0
  1936.            && stat (".", &dotstat) == 0
  1937.            && dotstat.st_ino == pwdstat.st_ino
  1938. !          && dotstat.st_dev == pwdstat.st_dev
  1939. ! #endif
  1940. !          ))
  1941.   
  1942.       /* The shortcut didn't work.  Try the slow, ``sure'' way.  */
  1943.       for (s = GUESSPATHLEN;  ! getcwd (p = xmalloc (s), s);  s *= 2)
  1944. diff -c -r ngcc/toplev.c gcc/toplev.c
  1945. *** ngcc/toplev.c    Mon Nov 30 15:36:25 1992
  1946. --- gcc/toplev.c    Mon Dec 28 00:27:55 1992
  1947. ***************
  1948. *** 31,37 ****
  1949.   
  1950.   #include <sys/stat.h>
  1951.   
  1952. ! #ifdef USG
  1953.   #undef FLOAT
  1954.   #include <sys/param.h>
  1955.   /* This is for hpux.  It is a real screw.  They should change hpux.  */
  1956. --- 31,37 ----
  1957.   
  1958.   #include <sys/stat.h>
  1959.   
  1960. ! #if defined(USG) || defined(CROSSHPUX)
  1961.   #undef FLOAT
  1962.   #include <sys/param.h>
  1963.   /* This is for hpux.  It is a real screw.  They should change hpux.  */
  1964. ***************
  1965. *** 41,49 ****
  1966. --- 41,57 ----
  1967.   #undef FFS  /* Some systems define this in param.h.  */
  1968.   #else
  1969.   #ifndef VMS
  1970. + #if (!(defined(atarist) || defined(atariminix)))
  1971.   #include <sys/time.h>
  1972.   #include <sys/resource.h>
  1973. + #endif /* !(atarist || atariminix) */
  1974. + #endif
  1975.   #endif
  1976. + 
  1977. + #ifdef atariminix
  1978. + #include <sys/times.h>
  1979. + /* #include <minix/const.h>, avoid dragging this in */
  1980. + #define HZ 60    /* this is the only thing needed from minix/const.h */
  1981.   #endif
  1982.   
  1983.   #include "input.h"
  1984. ***************
  1985. *** 57,62 ****
  1986. --- 65,75 ----
  1987.   #include "xcoffout.h"
  1988.   #endif
  1989.   
  1990. + #ifdef atarist
  1991. + long _stksize = -1L;    /* for all sizes of ST's */
  1992. +     /* -1 means malloc from own heap and keep all  of memory */
  1993. + #endif /* atarist */
  1994. + 
  1995.   #ifdef VMS
  1996.   /* The extra parameters substantially improve the I/O performance.  */
  1997.   static FILE *
  1998. ***************
  1999. *** 738,744 ****
  2000.   int
  2001.   get_run_time ()
  2002.   {
  2003. ! #ifdef USG
  2004.     struct tms tms;
  2005.   #else
  2006.   #ifndef VMS
  2007. --- 751,760 ----
  2008.   int
  2009.   get_run_time ()
  2010.   {
  2011. ! #ifdef atarist
  2012. !   long now;
  2013. ! #else
  2014. ! #if (defined(USG) || defined(atariminix) || defined(CROSSHPUX))
  2015.     struct tms tms;
  2016.   #else
  2017.   #ifndef VMS
  2018. ***************
  2019. *** 753,763 ****
  2020.       } vms_times;
  2021.   #endif
  2022.   #endif
  2023.   
  2024.     if (quiet_flag)
  2025.       return 0;
  2026.   
  2027. ! #ifdef USG
  2028.     times (&tms);
  2029.     return (tms.tms_utime + tms.tms_stime) * (1000000 / HZ);
  2030.   #else
  2031. --- 769,783 ----
  2032.       } vms_times;
  2033.   #endif
  2034.   #endif
  2035. + #endif
  2036.   
  2037.     if (quiet_flag)
  2038.       return 0;
  2039.   
  2040. ! #ifdef atarist
  2041. !   return(time(NULL) * 1000000);
  2042. ! #else
  2043. ! #if (defined(USG) || defined(atariminix) || defined(CROSSHPUX))
  2044.     times (&tms);
  2045.     return (tms.tms_utime + tms.tms_stime) * (1000000 / HZ);
  2046.   #else
  2047. ***************
  2048. *** 770,775 ****
  2049. --- 790,796 ----
  2050.     return (vms_times.proc_user_time + vms_times.proc_system_time) * 10000;
  2051.   #endif
  2052.   #endif
  2053. + #endif
  2054.   }
  2055.   
  2056.   #define TIMEVAR(VAR, BODY)    \
  2057. ***************
  2058. *** 1406,1411 ****
  2059. --- 1427,1433 ----
  2060.     longjmp (float_handler, 1);
  2061.   }
  2062.   
  2063. + #ifndef atarist
  2064.   /* Handler for SIGPIPE.  */
  2065.   
  2066.   static void
  2067. ***************
  2068. *** 1415,1420 ****
  2069. --- 1437,1443 ----
  2070.   {
  2071.     fatal ("output pipe has been closed");
  2072.   }
  2073. + #endif
  2074.   
  2075.   /* Strip off a legitimate source ending from the input string NAME of
  2076.      length LEN. */
  2077. ***************
  2078. *** 1446,1451 ****
  2079. --- 1469,1475 ----
  2080.       name[len - 4] = 0;
  2081.   }
  2082.   
  2083. + #ifdef SYSV
  2084.   /* Output a file name in the form wanted by System V.  */
  2085.   
  2086.   void
  2087. ***************
  2088. *** 1474,1479 ****
  2089. --- 1498,1504 ----
  2090.   #endif
  2091.   #endif
  2092.   }
  2093. + #endif
  2094.   
  2095.   /* Compile an entire file of output from cpp, named NAME.
  2096.      Write a file of assembly output and various debugging dumps.  */
  2097. ***************
  2098. *** 1573,1579 ****
  2099. --- 1598,1608 ----
  2100.       {
  2101.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
  2102.         strcpy (dumpname, dump_base_name);
  2103. + #ifndef atarist
  2104.         strcat (dumpname, ".jump");
  2105. + #else
  2106. +       strcat (dumpname, ".jmp");
  2107. + #endif
  2108.         jump_opt_dump_file = fopen (dumpname, "w");
  2109.         if (jump_opt_dump_file == 0)
  2110.       pfatal_with_name (dumpname);
  2111. ***************
  2112. *** 1595,1601 ****
  2113. --- 1624,1634 ----
  2114.       {
  2115.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
  2116.         strcpy (dumpname, dump_base_name);
  2117. + #ifndef atarist
  2118.         strcat (dumpname, ".loop");
  2119. + #else
  2120. +       strcat (dumpname, ".lop");
  2121. + #endif
  2122.         loop_dump_file = fopen (dumpname, "w");
  2123.         if (loop_dump_file == 0)
  2124.       pfatal_with_name (dumpname);
  2125. ***************
  2126. *** 1606,1612 ****
  2127. --- 1639,1649 ----
  2128.       {
  2129.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
  2130.         strcpy (dumpname, dump_base_name);
  2131. + #ifndef atarist
  2132.         strcat (dumpname, ".cse2");
  2133. + #else
  2134. +       strcat (dumpname, ".cs2");
  2135. + #endif
  2136.         cse2_dump_file = fopen (dumpname, "w");
  2137.         if (cse2_dump_file == 0)
  2138.       pfatal_with_name (dumpname);
  2139. ***************
  2140. *** 1617,1623 ****
  2141. --- 1654,1664 ----
  2142.       {
  2143.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
  2144.         strcpy (dumpname, dump_base_name);
  2145. + #ifndef atarist
  2146.         strcat (dumpname, ".flow");
  2147. + #else
  2148. +       strcat (dumpname, ".flo");
  2149. + #endif
  2150.         flow_dump_file = fopen (dumpname, "w");
  2151.         if (flow_dump_file == 0)
  2152.       pfatal_with_name (dumpname);
  2153. ***************
  2154. *** 1628,1634 ****
  2155. --- 1669,1679 ----
  2156.       {
  2157.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 10);
  2158.         strcpy (dumpname, dump_base_name);
  2159. + #ifndef atarist
  2160.         strcat (dumpname, ".combine");
  2161. + #else
  2162. +       strcat (dumpname, ".cmb");
  2163. + #endif
  2164.         combine_dump_file = fopen (dumpname, "w");
  2165.         if (combine_dump_file == 0)
  2166.       pfatal_with_name (dumpname);
  2167. ***************
  2168. *** 1639,1645 ****
  2169. --- 1684,1694 ----
  2170.       {
  2171.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 7);
  2172.         strcpy (dumpname, dump_base_name);
  2173. + #ifndef atarist
  2174.         strcat (dumpname, ".sched");
  2175. + #else
  2176. +       strcat (dumpname, ".sch");
  2177. + #endif
  2178.         sched_dump_file = fopen (dumpname, "w");
  2179.         if (sched_dump_file == 0)
  2180.       pfatal_with_name (dumpname);
  2181. ***************
  2182. *** 1650,1656 ****
  2183. --- 1699,1709 ----
  2184.       {
  2185.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
  2186.         strcpy (dumpname, dump_base_name);
  2187. + #ifndef atarist
  2188.         strcat (dumpname, ".lreg");
  2189. + #else
  2190. +       strcat (dumpname, ".lrg");
  2191. + #endif
  2192.         local_reg_dump_file = fopen (dumpname, "w");
  2193.         if (local_reg_dump_file == 0)
  2194.       pfatal_with_name (dumpname);
  2195. ***************
  2196. *** 1661,1667 ****
  2197. --- 1714,1724 ----
  2198.       {
  2199.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
  2200.         strcpy (dumpname, dump_base_name);
  2201. + #ifndef atarist
  2202.         strcat (dumpname, ".greg");
  2203. + #else
  2204. +       strcat (dumpname, ".grg");
  2205. + #endif
  2206.         global_reg_dump_file = fopen (dumpname, "w");
  2207.         if (global_reg_dump_file == 0)
  2208.       pfatal_with_name (dumpname);
  2209. ***************
  2210. *** 1672,1678 ****
  2211. --- 1729,1739 ----
  2212.       {
  2213.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 8);
  2214.         strcpy (dumpname, dump_base_name);
  2215. + #ifndef atarist
  2216.         strcat (dumpname, ".sched2");
  2217. + #else
  2218. +       strcat (dumpname, ".sc2");
  2219. + #endif
  2220.         sched2_dump_file = fopen (dumpname, "w");
  2221.         if (sched2_dump_file == 0)
  2222.       pfatal_with_name (dumpname);
  2223. ***************
  2224. *** 1683,1689 ****
  2225. --- 1744,1754 ----
  2226.       {
  2227.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 7);
  2228.         strcpy (dumpname, dump_base_name);
  2229. + #ifndef atarist
  2230.         strcat (dumpname, ".jump2");
  2231. + #else
  2232. +       strcat (dumpname, ".jp2");
  2233. + #endif
  2234.         jump2_opt_dump_file = fopen (dumpname, "w");
  2235.         if (jump2_opt_dump_file == 0)
  2236.       pfatal_with_name (dumpname);
  2237. ***************
  2238. *** 1707,1713 ****
  2239. --- 1772,1782 ----
  2240.       {
  2241.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 10);
  2242.         strcpy (dumpname, dump_base_name);
  2243. + #ifndef atarist
  2244.         strcat (dumpname, ".stack");
  2245. + #else
  2246. +       strcat (dumpname, ".stk");
  2247. + #endif
  2248.         stack_reg_dump_file = fopen (dumpname, "w");
  2249.         if (stack_reg_dump_file == 0)
  2250.       pfatal_with_name (dumpname);
  2251. ***************
  2252. *** 2748,2759 ****
  2253. --- 2817,2838 ----
  2254.     int version_flag = 0;
  2255.     char *p;
  2256.   
  2257. + #ifdef atarist
  2258. + /* turn this on if you are going to set the TOS 1.4 dont clear heap flag */
  2259. + /*  _malloczero(1); */     /* zero mallocs by default */
  2260. + #endif  
  2261. + 
  2262.     /* save in case md file wants to emit args as a comment.  */
  2263.     save_argc = argc;
  2264.     save_argv = argv;
  2265.   
  2266.     p = argv[0] + strlen (argv[0]);
  2267. + #ifndef atarist
  2268.     while (p != argv[0] && p[-1] != '/') --p;
  2269. + #else
  2270. +   while (p != argv[0] && ((p[-1] != '/') && (p[-1] != '\\') &&
  2271. +               (p[-1] != ':'))) --p;
  2272. + #endif
  2273.     progname = p;
  2274.   
  2275.   #ifdef RLIMIT_STACK
  2276. ***************
  2277. *** 2770,2776 ****
  2278. --- 2849,2857 ----
  2279.   
  2280.     signal (SIGFPE, float_signal);
  2281.   
  2282. + #ifndef atarist
  2283.     signal (SIGPIPE, pipe_closed);
  2284. + #endif
  2285.   
  2286.     decl_printable_name = decl_name;
  2287.     lang_expand_expr = (struct rtx_def *(*)()) do_abort;
  2288. ***************
  2289. *** 2868,2873 ****
  2290. --- 2949,2964 ----
  2291.         else if (!strcmp (str, "dumpbase"))
  2292.           {
  2293.             dump_base_name = argv[++i];
  2294. + #ifdef atarist
  2295. + /* dump_base_name will typically be 'foo.c' here.  Need to truncate at the '.',
  2296. +    cause dots mean something here */
  2297. +         {
  2298. +           char * n = dump_base_name;
  2299. +           for ( ; ((*n) && (*n != '.')) ; )
  2300. +         n++;
  2301. +           *n = '\0';
  2302. +         }
  2303. + #endif
  2304.           }
  2305.         else if (str[0] == 'd')
  2306.           {
  2307. ***************
  2308. *** 3263,3269 ****
  2309. --- 3354,3366 ----
  2310.        option flags in use.  */
  2311.     if (version_flag)
  2312.       {
  2313. + #if (defined(atarist) || defined(CROSSATARI) || defined(atariminix))
  2314. + #include "PatchLev.h"
  2315. +         fprintf (stderr, "%s version %s-atariST Patchlevel %s",
  2316. +          language_string, version_string, PatchLevel);
  2317. + #else
  2318.         fprintf (stderr, "%s version %s", language_string, version_string);
  2319. + #endif
  2320.   #ifdef TARGET_VERSION
  2321.         TARGET_VERSION;
  2322.   #endif
  2323. ***************
  2324. *** 3284,3289 ****
  2325. --- 3381,3388 ----
  2326.   
  2327.     compile_file (filename);
  2328.   
  2329. + #if (!(defined(atarist) || defined(atariminix)))
  2330. + #if (!(defined(CROSSHPUX)))
  2331.   #ifndef OS2
  2332.   #ifndef VMS
  2333.     if (flag_print_mem)
  2334. ***************
  2335. *** 3302,3307 ****
  2336. --- 3401,3408 ----
  2337.       }
  2338.   #endif /* not VMS */
  2339.   #endif /* not OS2 */
  2340. + #endif
  2341. + #endif
  2342.   
  2343.     if (errorcount)
  2344.       exit (FATAL_EXIT_CODE);
  2345. ***************
  2346. *** 3413,3415 ****
  2347. --- 3514,3547 ----
  2348.   
  2349.     fprintf (stderr, "\n");
  2350.   }
  2351. + 
  2352. + #ifdef atarist
  2353. + void atari_output_filename(file, filename)
  2354. + FILE *file;
  2355. + char *filename;
  2356. + {
  2357. +     if( (!file) || (!filename) ) return;
  2358. +     for(; *filename; filename++)
  2359. +     {
  2360. +     if(*filename == '\\') putc('\\', file);
  2361. +     putc(*filename, file);
  2362. +     }
  2363. + }
  2364. + 
  2365. + #include <string.h>
  2366. + 
  2367. + char *atari_filename_nondirectory(p)
  2368. + char *p;
  2369. + {
  2370. +     char *s;
  2371. +     
  2372. +     for(s = p + strlen(p); s != p; --s)
  2373. +     {
  2374. +     if((*s == '/') || (*s == '\\'))
  2375. +         break;
  2376. +     }
  2377. +     
  2378. +     return (s == p) ? p : s+1;
  2379. + }
  2380. + 
  2381. + #endif
  2382. diff -c -r ngcc/varasm.c gcc/varasm.c
  2383. *** ngcc/varasm.c    Mon Dec 28 00:45:17 1992
  2384. --- gcc/varasm.c    Mon Dec 28 00:27:57 1992
  2385. ***************
  2386. *** 978,991 ****
  2387.   assemble_external_libcall (fun)
  2388.        rtx fun;
  2389.   {
  2390. - #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
  2391.     /* Declare library function name external when first used, if nec.  */
  2392.     if (! SYMBOL_REF_USED (fun))
  2393.       {
  2394.         SYMBOL_REF_USED (fun) = 1;
  2395.         ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
  2396. -     }
  2397.   #endif
  2398.   }
  2399.   
  2400.   /* Declare the label NAME global.  */
  2401. --- 978,991 ----
  2402.   assemble_external_libcall (fun)
  2403.        rtx fun;
  2404.   {
  2405.     /* Declare library function name external when first used, if nec.  */
  2406.     if (! SYMBOL_REF_USED (fun))
  2407.       {
  2408.         SYMBOL_REF_USED (fun) = 1;
  2409. + #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
  2410.         ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
  2411.   #endif
  2412. +     }
  2413.   }
  2414.   
  2415.   /* Declare the label NAME global.  */
  2416. ***************
  2417. *** 2232,2237 ****
  2418. --- 2232,2240 ----
  2419.        rtx x;
  2420.   {
  2421.     struct rtx_const val0, val1;
  2422. + 
  2423. +   if (XEXP (x, 0) == pc_rtx || XEXP (x, 1) == pc_rtx)
  2424. +     return XEXP (x, 0) == XEXP (x, 1) ? const0_rtx : x;
  2425.   
  2426.     decode_rtx_const (GET_MODE (x), XEXP (x, 0), &val0);
  2427.     decode_rtx_const (GET_MODE (x), XEXP (x, 1), &val1);
  2428.